home *** CD-ROM | disk | FTP | other *** search
/ Resource for Source: C/C++ / Resource for Source - C-C++.iso / codelib7 / v_09_03 / 9n03035a < prev    next >
Encoding:
Text File  |  1995-11-01  |  6.3 KB  |  170 lines
  1.          title     multask.s
  2.          name      mtask
  3. *********************************************************************
  4. *
  5. * NAME        :
  6. *
  7. * DESCRIPTION : multasking routines for the motorola 68xx series
  8. *               of microcomputers
  9. *
  10. *             init_task(task#, task_address) /* called from system mode */
  11. *             continue_task(task#)           /* called from system mode */
  12. *             suspend()                      /* called from task mode   */
  13. *
  14. *             The task_mode flag to keep track of which mode is in effect
  15. *             allows the use of subroutines hat are called by both system
  16. *             and task code.  If those subroutines call suspend(). then in
  17. *             the case of a system mode caller syspend() must return con-
  18. *             trol immediately.
  19. *
  20. *********************************************************************/
  21.  
  22. * COMMON DEFINITIONS */
  23.  
  24. stksize  equ  255
  25. tasks    equ  4
  26.  
  27.    xref SF     ;Stack Frame
  28.  
  29.  
  30.         SECTION DATA,?,DATA
  31.  
  32. sys_stk       dw   0
  33. sys_sf        dw   0
  34. task_num      dw   0
  35. task_mode     db   0
  36. tstk          dw   0                ; temporary stack storage
  37. task_tab      ds   tasks*2          ; tasks words
  38. fram_tab      ds   tasks*2          ; frame words
  39.         SECTION STACK,?,DATA
  40.    xdef  _task_stks, task_stks
  41. _task_stks
  42. task_stks     ds   stksize*(tasks+1)
  43. pad2          dw   0                ; end boundry for data
  44.    xdef  _sp?
  45. _sp?: DS 2
  46. pad3          dw   0                ; end boundry for stacks
  47.  
  48.  
  49.         SECTION PROGRAM_CODE,?,CODE
  50.  
  51.          xdef      init_task?
  52.          xdef      continue_task?
  53.          xdef      suspend?
  54.  
  55. *********************************************************************
  56. *
  57. * NAME       : init_task(task_number, task_address)
  58. *
  59. * DESCRIPTION: initializes the task specified by the task address
  60. *              saves the stack pointer into sys_stack
  61. *              saves the task number into task_num
  62. *              calculates the beginning of the task's stack
  63. *              loads the stack pointer with the results of the preceeding
  64. *                 calculation
  65. *              sets task_mode to one to indicate that we are in task mode
  66. *                 push address of callsus to new stack in case the task returns
  67. *                 this prepares the return address of a hung task that re-
  68. *                 peatedly gives up control by calling suspend
  69. *              this routine drops through to suspend.
  70. *              so in effect this routine sets up a task with a stack then
  71. *              prepares the stack for the next call as if it were running
  72. *              then suspends itself.
  73. *
  74.  
  75. init_task?:
  76.          sts  sys_stk             ; Save the system stack
  77.          std  task_num            ; save parameter task number for later
  78.          ldd  SF                  ; get stack frame pointer and save into
  79.          std  sys_sf              ; system variable
  80.          ldd  task_num
  81.          ldaa #stksize            ; make calculation of task_num times
  82.          mul                      ; stack size then add to beginning
  83.          addd #(task_stks+stksize)      ; of stack pool
  84.          std  tstk                ; put d into temporary stack storage
  85.          lds  tstk                ; get new stack from temp. stack storage
  86.          subd #3                  ; adjust frame pointer for next routine
  87.          std  SF                  ; load new stack frame pointer
  88.          inc  task_mode           ; put us into task mode
  89.          ldd  #callsus            ; get address of suspend and
  90.          pshb                     ; load it into the new stack
  91.          psha                     ;
  92.          pshx                     ; save stack into new stack
  93.  
  94. * fall through to next routine (suspend)
  95.  
  96. *********************************************************************
  97. *
  98. * NAME       : suspend()
  99. *
  100. * DESCRIPTION: suspend the current task by saving the current stack
  101. *              stack pointer into the task table and then getting the
  102. *              system stack and transfer control to the system, setting
  103. *              task mode to 0 and start executing the next task in the
  104. *              master while loop in main.
  105. *
  106.  
  107. suspend?:                     ; see if we are in task mode if s?o
  108.          tst  task_mode      ; go to suspend task
  109.          bne  sustsk         ; else return
  110.          rts
  111.  
  112. sustsk:
  113.          ldd  task_num       ; get the task number and multiply by two
  114.          lsld                ; for indexing purposes into the task table
  115.          ldx  #task_tab
  116.          abx
  117.          sts  x              ; store the stack into the proper table entry
  118.          ldx  #fram_tab      ; get address of frame table and store SF
  119.          abx                 ; into indexed address of frame table array
  120.          ldd  SF
  121.          std  x
  122.          lds  sys_stk        ; restore the system stack
  123.          ldd  sys_sf         ; restore stack frame pointer
  124.          std  SF
  125.          clr  task_mode      ; go into system mode
  126.          rts                 ; and return
  127.  
  128. *********************************************************************
  129. *
  130. * NAME       : continue(task_number)
  131. *
  132. * DESCRIPTION: continues the task specified by the task number
  133. *              get the task number in the task table
  134. *              loads the stack pointer at the table index
  135. *              set task mode to one indication we are task mode
  136. *              and returns
  137. *
  138. *
  139.  
  140. continue_task?:
  141.          sts  sys_stk        ; store the stack
  142.          std  task_num       ; save into variable task_num
  143.          ldd  SF
  144.          std  sys_sf
  145.          ldd  task_num
  146.          lsld                ; multiply task number by 2
  147.          ldx  #task_tab      ; get address of tasktable into index
  148.          abx                 ; add (task num * 2) + table address
  149.          lds  x              ; load new stack into sp
  150.          ldx  #fram_tab      ; get the task's frame pointer and update
  151.          abx                 ; the frame pointer
  152.          ldd  x
  153.          std  SF
  154.          inc  task_mode      ; set task mode to task
  155.          rts                 ; return ( to new task)
  156.  
  157. *********************************************************************
  158. *
  159. * NAME       : callsus
  160. *
  161. * DESCRIPTION: this routine is in case the task returns all the way
  162. *              back to the main routine.
  163. *
  164.  
  165. callsus:
  166.          bsr  suspend?
  167.          bra  callsus
  168.  
  169.          end
  170.